package com.cx.anno;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author zhangshuai
 * @version V1.0
 * @Project Java2_26
 * @Package com.cx.anno
 * @Description:
 * @Date 2025/5/21 21:35
 */

public class Demo2 {
    //Lambda表达式：主要是用于实现函数式接口（只有一个抽象方法的函数），简化匿名内部类的写法
    //Lambda表达式是一种匿名函数，可以作为参数传递给方法,主要作用，简化代码
    //语法：(参数列表) -> { 方法体 }
    //常见的函数式接口有：
    //Consumer<T>：接受一个参数，无返回值    BiConsumer<T, U>：接受两个参数，无返回值
    //Supplier<T>：无参数，返回一个结果        BiSupplier<T, U>：无参数，返回两个结果
    //Function<T, R>：接受一个参数，返回一个结果   BiFunction<T, U, R>：接受两个参数，返回一个结果
    //Predicate<T>：接受一个参数，返回一个布尔值       BiPredicate<T, U>：接受两个参数，返回一个布尔值
    //Lambda表达式的使用场景：
    //方法引用：
    //静态方法引用：ClassName::staticMethod

    //实例方法引用：object::instanceMethod
    //类方法引用：ClassName::instanceMethod
    //构造方法引用：ClassName::new
    //集合操作：
    public static void main(String[] args) {
        // 2. 有参数，无返回值
      Consumer<String> consumer = (s) -> {
            System.out.println(s);
        };
      consumer.accept("Hello, Lambda123456!");
      // 3. 无参数，有返回值
        Supplier<String> supplier = () -> {
            return "Hello, Lambda!";
        };
        System.out.println(supplier.get());
        // 4. 有参数，有返回值
        Function<String, Integer> function = (s) -> {
            return s.length();
        };
        System.out.println(function.apply("Hello, Lambda11111111111!"));

        // 5. 多个参数，有返回值
        Predicate<String> predicate = (s) -> {
            return s.length() > 5;
        };

        System.out.println(predicate.test("Hello, Lambda!"));
        // 6. 多个参数，无返回值
        Consumer<String> consumer1 = (s) -> {
            System.out.println(s);
        };
      SimpleFunctionalInterface simpleFunctionalInterface = () -> {
            System.out.println("Hello, Lambda!");
        };

        simpleFunctionalInterface.execute();

     Comparator comparator1 =   new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        };

        Comparator<Integer> comparator = (o1, o2) -> o1 - o2;


    }


}

@FunctionalInterface
 interface SimpleFunctionalInterface {
    void execute();
}